import java.lang.reflect.Array;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User:张熳
 * Date:2025-08-13
 * Time:13:41
 */
//数组的定义与使用

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        //在C语言中，二维数组可以省略行数，不可以省略列数，而在Java中，不可以省略行数，可以省略列数
        int[][] array = new int[2][];//这叫 不规则二维数组
        array[0] = new int[3];
        //array[1] = new int[3];
        array[1] = new int[5];

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
    public static void main10(String[] args) {
        int[][] array = {{1,2,3},{4,5,6}};
        String ret = Arrays.toString(array);
        System.out.println(ret);//[[I@4eec7777, [I@3b07d329]
        //deepToString - 返回指定数组的“深度内容”的字符串
        String ret1 = Arrays.deepToString(array);
        System.out.println(ret1);//[[1, 2, 3], [4, 5, 6]]
    }
    public static void main9(String[] args) {
        //遍历二维数组
        int[][] array = {{1,2,3},{4,5,6}};
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(Arrays.toString(array[0]));
        System.out.println(Arrays.toString(array[1]));

        System.out.println(array.length);//行数
        System.out.println(array[0].length);//第一行的元素的个数，即一维数组的长度
        System.out.println(array[1].length);//第二行
        //在遍历二维数组时，行数和列数就可以这样：
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("=====");
        //使用for-each 遍历
        for (int[] tmpArray:array) {
            for (int x:tmpArray) {
                System.out.print(x + " ");
            }
            System.out.println();
        }
    }
    public static void main8(String[] args) {
        //二维数组--本质上也就是一维数组, 只不过每个元素又是一个一维数组
        int[][] array = {new int[]{1,2,3},new int[]{4,5,6}};
        //简写：
        int[][] array1 = {{1,2,3},{4,5,6}};//在C语言中，写二维数组时，并不需要加{},但是在Java中必须加

        int[][] array2 = new int[][]{{1,2,3},{4,5,6}};
        int[][] array3 = new int[2][3];//默认都是0
    }
    public static void main7(String[] args) {
        //是不是传引用就能修改实参的值？
        int[] array = {1,2,3,4,5,6};
        func2(array);
        System.out.println(Arrays.toString(array));
    }
    public static void func1(int[] array){
        array[0] = 99;
    }
    public static void func2(int[] array){
        array = new int[]{9,8,7,6,5};
    }
    //将数组当中的每个数据扩大2倍
    public static int[] fun(int[] array){
        int[] ret = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            ret[i] = array[i]*2;
        }
        return ret;
    }
    //在数组本身上扩大
    public static void fun1(int[] array){
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i]*2;
        }
    }
    public static void main6(String[] args) {
        int[] array = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(array));
        fun1(array);
        System.out.println(Arrays.toString(array));
        /*int[] tmp = fun(array);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(tmp));*/
    }
    public static void main5(String[] args) {
        //null-null 在 Java 中表示 "空引用" , 也就是一个不指向对象的引用.
        int[] array = null;
        //System.out.println(array.length);
        System.out.println(array[0]);
    }
    public static void main4(String[] args) {
        //基本类型变量与引用类型变量的区别
        int[] array1 = new int[3];
        array1[0] = 10;
        array1[1] = 20;
        array1[2] = 30;

        int[] array2 = new int[]{1, 2, 3, 4, 5};
        array2[0] = 100;
        array2[1] = 200;

        array1 = array2;//array1这个引用指向array2这个引用所指向的对象
        array1[2] = 300;
        array1[3] = 400;
        array2[4] = 500;
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);//100 200 300 400 500
        }
    }
    public static void main3(String[] args) {
        //数组是引用类型
        int[] array = {1,2,3,4,5,6};
        System.out.println(array);
    }
    public static void main2(String[] args) {
        //元素访问
        int[] array = {1,2,3,4,5,6};
        //System.out.println(array[5]);//6
        //遍历数组
        //1
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        System.out.print("使用for-each:");
        //2也可以使用 for-each 遍历数组
        for (int x:array) {  //遍历array数组，取出每一个元素放在x中，每取一个打印一个（但是该方式无法取到元素对应的下标）
            System.out.print(x + " ");
        }
        System.out.println();
        //3 使用操作数组的工具类 Arrays (需要导入包)，实现遍历数组
        String ret = Arrays.toString(array);//Array的toString方法:将数组以字符串的形式输出
        System.out.println(ret);
    }
    public static void main1(String[] args) {
        //数组的创建及初始化
        //array叫做引用变量，简称引用；new关键字表示创建新的对象，在这里表示创建数组对象（数组）
        int[] array = new int[]{1,2,3,4,5,6};//静态初始化-在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
        int[] array1 = {1,2,3,4,5,6};//静态初始化简写
        int[] array2 = new int[10];//动态初始化-在创建数组时，直接指定数组中元素的个数,这种定义方式并没有初始化当前指定的值，默认0

        //静态和动态初始化也可以分为两步
        int[] array3;
        array3 = new int[4];

        int[] array4;
        array4 = new int[]{1,2,3,4};
        //省略格式不可以-对数组进行整体的初始化，只能是在定义这个数组的时候
        /*int[] array5;
        array5 = {1,2,3,4};*/

        boolean[] array6 = new boolean[3];//默认值为false
    }
}
